import React from 'react';
import { connect } from 'dva';
import { Button, message } from 'antd';
import { FormGroup, DATA_ENTRY } from '../../../../../comps';
import moment from 'moment';
class ZcReportInfo extends React.Component {
  constructor() {
    super();
    this.state = {
      permissonBefore: false,
      //是否有浮动因子
      jgbb_sfyfdyz1: undefined,
      //收/受益权类型
      jgbb_ssyqlx1: undefined,
      //融资人类型按规模化分
      jgbb_rzrlxgm: undefined,
      //融资人类型按技术划分
      jgbb_rzrlxjs: undefined,
      //融资人类型按经济划分
      jgbb_rzrlxjj: undefined,
      //项目是否属于重点监控
      jgbb_xmsfsyzdjkhyhly: undefined,
      //重点监控行业和领域类别
      jgbb_zdjkhyhlylb: undefined,
      //抵质押物类型
      jgbb_dzywlx: undefined,
      //担保人与融资人关系
      jgbb_dbryrzrgx: undefined,
      //含权类型
      jgbb_hqlx1: undefined,
      //行权方式
      jgbb_xqfs1: undefined,
      //永续条款类型
      jgbb_yxtklx: undefined,
      //利息递延条款类型
      jgbb_lxdytklx: undefined,
      //融资总费率
      jgbb_rzzfl: undefined,
      //基准利率种类
      jgbb_jzllzl: undefined,
      assetType: undefined,
      zcReportInfoRef: undefined,
    };
  }
  componentDidMount() {
    this.props.onRef && this.props.onRef(this);
    const { reportInfo = {} } = this.props;
    this.setState({
      jgbb_sfyfdyz1: reportInfo.jgbb_sfyfdyz1,
      jgbb_ssyqlx1: reportInfo.jgbb_ssyqlx1,
      jgbb_rzrlxgm: reportInfo.jgbb_rzrlxgm,
      jgbb_rzrlxjs: reportInfo.jgbb_rzrlxjs,
      jgbb_rzrlxjj: reportInfo.jgbb_rzrlxjj,
      jgbb_xmsfsyzdjkhyhly: reportInfo.jgbb_xmsfsyzdjkhyhly,
      jgbb_zdjkhyhlylb: reportInfo.jgbb_zdjkhyhlylb,
      jgbb_dzywlx: reportInfo.jgbb_dzywlx,
      jgbb_dbryrzrgx: reportInfo.jgbb_dbryrzrgx,
      jgbb_hqlx1: reportInfo.jgbb_hqlx1,
      jgbb_xqfs1: reportInfo.jgbb_xqfs1,
      jgbb_yxtklx: reportInfo.jgbb_yxtklx,
      jgbb_lxdytklx: reportInfo.jgbb_lxdytklx,
      jgbb_rzzfl: reportInfo.jgbb_rzzfl,
      jgbb_jzllzl: reportInfo.jgbb_jzllzl,
      assetType: this.props.baseBaseInfoChangeReport?.assetType,
    });
  }
  UNSAFE_componentWillReceiveProps(nextPorps) {
    if (JSON.stringify(nextPorps.reportInfo) != JSON.stringify(this.props.reportInfo)) {
      this.setState({
        jgbb_sfyfdyz1: nextPorps.reportInfo?.jgbb_sfyfdyz1,
        jgbb_ssyqlx1: nextPorps.reportInfo?.jgbb_ssyqlx1,
        jgbb_rzrlxgm: nextPorps.reportInfo?.jgbb_rzrlxgm,
        jgbb_rzrlxjs: nextPorps.reportInfo?.jgbb_rzrlxjs,
        jgbb_rzrlxjj: nextPorps.reportInfo?.jgbb_rzrlxjj,
        jgbb_xmsfsyzdjkhyhly: nextPorps.reportInfo?.jgbb_xmsfsyzdjkhyhly,
        jgbb_zdjkhyhlylb: nextPorps.reportInfo?.jgbb_zdjkhyhlylb,
        jgbb_dzywlx: nextPorps.reportInfo?.jgbb_dzywlx,
        jgbb_dbryrzrgx: nextPorps.reportInfo?.jgbb_dbryrzrgx,
        jgbb_hqlx1: nextPorps.reportInfo?.jgbb_hqlx1,
        jgbb_xqfs1: nextPorps.reportInfo?.jgbb_xqfs1,
        jgbb_yxtklx: nextPorps.reportInfo?.jgbb_yxtklx,
        jgbb_lxdytklx: nextPorps.reportInfo?.jgbb_lxdytklx,
        jgbb_rzzfl: nextPorps.reportInfo?.jgbb_rzzfl,
        jgbb_jzllzl: nextPorps.reportInfo?.jgbb_jzllzl,
      });
    }
    if (JSON.stringify(nextPorps.baseBaseInfoChangeReport) != JSON.stringify(this.props.baseBaseInfoChangeReport)) {
      this.setState({
        assetType: nextPorps.baseBaseInfoChangeReport.assetType,
      });
    }
  }
  //可供外部调用获取资产类报表信息
  getInfo = (callback) => {
    let values = this.state.zcReportInfoRef.getFormGroupData();
    if (values) {
      values.jgbb_fdyz = values?.jgbb_fdyz || values.jgbb_fdyz == 0 ? values.jgbb_fdyz / 100 : null;
      values.jgbb_lcbp = values?.jgbb_lcbp || values.jgbb_lcbp == 0 ? values.jgbb_lcbp / 100 : null;
      values.jgbb_cesyfpbl = values?.jgbb_cesyfpbl || values.jgbb_cesyfpbl == 0 ? values.jgbb_cesyfpbl / 100 : null;
      values.jgbb_bfshbl = values?.jgbb_bfshbl || values.jgbb_bfshbl == 0 ? values.jgbb_bfshbl / 100 : null;
      values.jgbb_rzzfl = values?.jgbb_rzzfl || values.jgbb_rzzfl == 0 ? values.jgbb_rzzfl / 100 : null;
      values.jgbb_fddqr = values?.jgbb_fddqr ? moment(values.jgbb_fddqr).format('YYYY-MM-DD') : '';
      values.jgbb_gdxqr1 = values?.jgbb_gdxqr1 ? moment(values.jgbb_gdxqr1).format('YYYY-MM-DD') : '';
      values.jgbb_scxqr1 = values?.jgbb_scxqr1 ? moment(values.jgbb_scxqr1).format('YYYY-MM-DD') : '';
      values.jgbb_sccdjrq = values?.jgbb_sccdjrq ? moment(values.jgbb_sccdjrq).format('YYYY-MM-DD') : '';
      //jgbb_fdyz 浮动因子
      //jgbb_lcbp 利差bp
      //jgbb_cesyfpbl 超额收益分配比例
      //jgbb_bfshbl  部分赎回比例
      //jgbb_rzzfl  融资总费率
      callback(values);
    } else {
      message.error('请填写完表单再提交！');
      return false;
    }
    // this.state.zcReportInfoRef.props.form.validateFieldsAndScroll(undefined,{force:true},(err,values)=>{
    //     if(err){
    //         message.error('请填写完表单再提交！');
    //         return false;
    //     }else{
    //         values.jgbb_fdyz = (values?.jgbb_fdyz || (values.jgbb_fdyz == 0))?(values.jgbb_fdyz)/100:null;
    //         values.jgbb_lcbp = (values?.jgbb_lcbp || (values.jgbb_lcbp == 0))?(values.jgbb_lcbp)/100 :null;
    //         values.jgbb_cesyfpbl=(values?.jgbb_cesyfpbl || (values.jgbb_cesyfpbl == 0))?(values.jgbb_cesyfpbl)/100:null;
    //         values.jgbb_bfshbl =(values?.jgbb_bfshbl || (values.jgbb_bfshbl == 0))?(values.jgbb_bfshbl)/100:null;
    //         values.jgbb_rzzfl=(values?.jgbb_rzzfl || (values.jgbb_rzzfl == 0))?(values.jgbb_rzzfl)/100:null;
    //         values.jgbb_fddqr = (values?.jgbb_fddqr) ? moment(values.jgbb_fddqr).format('YYYY-MM-DD'): '';
    //         values.jgbb_gdxqr1 = (values?.jgbb_gdxqr1)?moment(values.jgbb_gdxqr1).format('YYYY-MM-DD'):'';
    //         values.jgbb_scxqr1 = (values?.jgbb_scxqr1) ?moment(values.jgbb_scxqr1).format('YYYY-MM-DD'):'';
    //         values.jgbb_sccdjrq =(values?.jgbb_sccdjrq)?moment(values.jgbb_sccdjrq).format('YYYY-MM-DD'):'';
    //         //jgbb_fdyz 浮动因子
    //         //jgbb_lcbp 利差bp
    //         //jgbb_cesyfpbl 超额收益分配比例
    //         //jgbb_bfshbl  部分赎回比例
    //         //jgbb_rzzfl  融资总费率
    //         callback(values);
    //     }
    // })
  };
  //更改状态
  changeStatus = (e) => {
    this.setState({
      ...e,
    });
  };
  handleMedianValidator = (rule, val, callback) => {
    if (val == '无') {
      callback();
    } else {
      if (val) {
        if (!/^([0-9A-Z]{9}$)|([0-9A-Z]{18}$)/.test(val)) {
          callback('请填写为9位或18位大写字母或数字!');
        } else {
          callback();
        }
      }
    }
    callback();
  };
  render() {
    const {
      assetType,
      permissonBefore,
      jgbb_sfyfdyz1,
      jgbb_ssyqlx1,
      jgbb_rzrlxgm,
      jgbb_rzrlxjs,
      jgbb_rzrlxjj,
      jgbb_xmsfsyzdjkhyhly,
      jgbb_zdjkhyhlylb,
      jgbb_dzywlx,
      jgbb_dbryrzrgx,
      jgbb_hqlx1,
      jgbb_xqfs1,
      jgbb_yxtklx,
      jgbb_lxdytklx,
      jgbb_rzzfl,
      jgbb_jzllzl,
    } = this.state;
    const { disableStatus, nonstandarmaintenanceNewM, baseBaseInfoChangeReport = {}, reportInfo = {} } = this.props;
    const { dictMapSelect } = nonstandarmaintenanceNewM;
    const { guaranteeWay, startDate, endDate } = baseBaseInfoChangeReport;
    return (
      <>
        <FormGroup
          dataSource={[
            {
              dataIndex: 'jgbb_mc',
              title: '名称',
              type: DATA_ENTRY.INPUT,
              helper: '资产的全称',
              initialValue: reportInfo?.jgbb_mc,
              disabled: disableStatus,
              // span:8,
              rules: [
                { required: permissonBefore, message: '请输入' },
                { max: 200, message: '字符长度小于200' },
              ],
            },
            {
              dataIndex: 'jgbb_ssyqlx1',
              title: '收/受益权类型',
              helper: '收/受益权标的所对应的类别。',
              type: DATA_ENTRY.SELECT,
              initialValue: reportInfo?.jgbb_ssyqlx1,
              dataSource: dictMapSelect['NONSTANDAR_JGBB_SSYQLX1'],
              // allowClear: true,
              disabled: disableStatus || assetType == '3' || assetType == '4' || assetType == '6' || assetType == '7' || assetType == '8',
              // span:8,
              onChange: (e) => {
                this.props?.onBaseInfoChange({ jgbb_ssyqlx1: e }), this.changeStatus({ jgbb_ssyqlx1: e });
              },
              rules: [{ required: assetType == '2' ? true : ['2'].indexOf(assetType) > -1, message: '请选择' }],
            },
            {
              dataIndex: 'jgbb_sfsymrfs1',
              title: '是否属于买入返售',
              helper: '指是否通过买入返售形式投资资产',
              type: DATA_ENTRY.SELECT,
              isTrueFalseJudge: true,
              initialValue: reportInfo?.jgbb_sfsymrfs1,
              allowClear: true,
              disabled: disableStatus,
              // span:8,
              rules: [{ required: true, message: '请选择' }],
            },
            {
              dataIndex: 'jgbb_fddqr',
              title: '法定到期日',
              helper: (
                <span>
                  预期到期日之后的诉讼期结束处置资产的清算日期，
                  <br />
                  发行时在相关的发行文件中披露
                </span>
              ),
              type: DATA_ENTRY.SINGLEDATE,
              disabled: disableStatus,
              span: 8,
              initialValue: reportInfo?.jgbb_fddqr ? moment(new Date(reportInfo?.jgbb_fddqr)) : undefined,
            },
            {
              dataIndex: 'jgbb_xmqx',
              title: '项目期限',
              helper: '非标资产项目从起息日至到期日之间的存续期限',
              type: DATA_ENTRY.INPUTNUMBER,
              precision: 0,
              unit: '天',
              initialValue: startDate && endDate && moment(endDate) && moment(startDate) ? Number(moment(endDate).diff(moment(startDate), 'days')) + 1 : undefined, //计算公式：到期日-起息日+1
              disabled: true,
              span: '8',
            },
            {
              dataIndex: 'jgbb_sfyyqsyl',
              title: '是否有预期收益率',
              type: DATA_ENTRY.SELECT,
              isTrueFalseJudge: true,
              initialValue: reportInfo?.jgbb_sfyyqsyl,
              allowClear: true,
              disabled: disableStatus,
              onChange: (e) => {
                this.props?.changeYQSYL && this.props?.changeYQSYL(e);
              },
              span: 8,
              rules: [{ required: permissonBefore && true, message: '请选择' }],
            },
            {
              dataIndex: 'jgbb_jxlx',
              title: '计息类型',
              type: DATA_ENTRY.SELECT,
              helper: '约定的计算并支付利息的方式',
              dataSource: dictMapSelect['ASSETS_JXLX'],
              initialValue: reportInfo?.jgbb_jxlx,
              allowClear: true,
              disabled: disableStatus,
              span: 8,
              rules: [{ required: assetType == '3' || assetType == '4' || assetType == '6' || assetType == '7' || assetType == '8', message: '请选择' }],
            },
            {
              dataIndex: 'jgbb_gzfxbs',
              title: '规则付息标识',
              type: DATA_ENTRY.SELECT,
              isTrueFalseJudge: true,
              helper: '资产付息周期是否规律的标识',
              initialValue: reportInfo?.jgbb_gzfxbs,
              allowClear: true,
              disabled: disableStatus,
              span: 8,
              rules: [{ required: assetType == '3' || assetType == '2' || assetType == '4' || assetType == '6' || assetType == '7' || assetType == '8', message: '请选择' }],
            },
            {
              dataIndex: 'jgbb_lxfbfs',
              title: '利息分布方式',
              type: DATA_ENTRY.SELECT,
              helper: (
                <span>
                  付息周期小于 12 个月的附息式固定利率、附息式浮动利率资产的利息分配方式，
                  <br />
                  全年利息按照付息频率在各计息期间平均分配或按照各计息期的实际天数计算和分配
                </span>
              ),
              dataSource: dictMapSelect['ASSETS_LXFBFS'],
              initialValue: reportInfo?.jgbb_lxfbfs,
              allowClear: true,
              disabled: disableStatus,
              span: 8,
              rules: [{ required: assetType == '3' || assetType == '2' || assetType == '4' || assetType == '6' || assetType == '7' || assetType == '8', message: '请选择' }],
            },
            {
              dataIndex: 'jgbb_hbfxqksm',
              title: '还本付息情况说明',
              helper: (
                <span>
                  对资产项目还本付息情况的详细说明，尤其是针对收益率不固定、还本付息频率不规则等情况。
                  <br />
                  1.如无则填写“无”。
                  <br />
                  2.对于收益率不固定、还本付息频率不规则的非标资产，需要在该要素中枚举所有分配日期、
                  <br />
                  分配类型（本息/本金/利息）、计息起始日期、计息结束日期、执行利率、计息本金值、
                  <br />
                  兑付本金值，并使用“,”和“;”进行分隔，
                  <br />
                  例如：2019/10/18,息,2018/10/18,2019/10/18,6%,100,0;2020/10/18,本息,
                  <br />
                  2019/10/18,2020/10/18,7%,100,100
                </span>
              ),
              type: DATA_ENTRY.INPUT,
              showTextArea: true,
              lineOne: true,
              disabled: disableStatus,
              initialValue: reportInfo?.jgbb_hbfxqksm,
              span: 24,
              rules: [
                {
                  required: permissonBefore && true,
                  message: '请输入',
                },
              ],
            },
            {
              dataIndex: 'jgbb_jzllzl', //“项目收益率”“基准利率种类”不得同时为空
              title: '基准利率种类',
              type: DATA_ENTRY.SELECT,
              helper: '约定的计算并支付利息的方式',
              dataSource: dictMapSelect['ASSETS_JZLLZL'],
              initialValue: reportInfo?.jgbb_jzllzl,
              allowClear: true,
              disabled: disableStatus,
              onChange: (e) => {
                this.props?.onBaseInfoChange({ jgbb_jzllzl: e }), this.changeStatus({ jgbb_jzllzl: e });
              },
              span: 8,
            },
            {
              dataIndex: 'jgbb_sfyfdyz1',
              title: '是否有浮动因子',
              type: DATA_ENTRY.SELECT,
              helper: '项目收益率是否使用基准利率上下浮动固定比率',
              isTrueFalseJudge: true,
              initialValue: reportInfo?.jgbb_sfyfdyz1,
              allowClear: true,
              onChange: (e) => {
                this.props?.onBaseInfoChange({ jgbb_sfyfdyz1: e }), this.changeStatus({ jgbb_sfyfdyz1: e });
              },
              disabled: disableStatus,
              span: 8,
              rules: [{ required: assetType == '3' || assetType == '2' || assetType == '4' || assetType == '6' || assetType == '7' || assetType == '8', message: '请选择' }],
            },
            {
              dataIndex: 'jgbb_fdyz',
              title: '浮动因子',
              helper: '项目收益率在基准利率基础上上浮或下浮的比率',
              type: DATA_ENTRY.INPUTNUMBER,
              precision: 5,
              unit: '%',
              disabled: disableStatus || jgbb_sfyfdyz1 == '0',
              initialValue: reportInfo?.jgbb_fdyz || (reportInfo && reportInfo.jgbb_fdyz == 0) ? reportInfo?.jgbb_fdyz * 100 : null,
              rules: [
                { pattern: /(^-?(?:\d|\d{0,2})(?:\.\d{0,5})?$)/, message: '字符不能超过8位！' },
                {
                  required: (assetType == '3' || assetType == '2' || assetType == '4' || assetType == '6' || assetType == '7' || assetType == '8') && jgbb_sfyfdyz1 == '1',
                  message: '请选择',
                },
              ],
              span: '8',
            },
            {
              dataIndex: 'jgbb_lcbp',
              title: '利差(BP)',
              helper: '项目收益率与基准利率的差值',
              type: DATA_ENTRY.INPUTNUMBER,
              precision: 5,
              unit: '%',
              disabled: disableStatus,
              initialValue: reportInfo?.jgbb_lcbp || (reportInfo && reportInfo.jgbb_lcbp == 0) ? parseFloat((reportInfo?.jgbb_lcbp * 100000) / 1000).toFixed(5) : null,
              rules: [{ pattern: /(^-?(?:\d|\d{0,2})(?:\.\d{0,5})?$)/, message: '字符不能超过8位！' }],
              span: '8',
            },
            {
              dataIndex: 'jgbb_jgdc',
              title: '结构档次',
              type: DATA_ENTRY.SELECT,
              helper: (
                <span>
                  资产在资产包现金流分配机制中的现金偿还次序，
                  <br />
                  相同结构档次的债权类资产具有
                  <br />
                  相同的收益分配顺序。
                  <br />
                  优先 A1、优先 A2 归为优先 A
                </span>
              ),
              dataSource: dictMapSelect['ASSETS_JGDC'],
              initialValue: reportInfo?.jgbb_jgdc,
              allowClear: true,
              disabled: disableStatus,
              span: 8,
            },
            {
              dataIndex: 'jgbb_hbfs1',
              title: '还本方式',
              type: DATA_ENTRY.SELECT,
              helper: (
                <span>
                  结构化资产约定的还本方式是根据基础资产现金流回收情况过手摊还，
                  <br />
                  或根据固定的摊还计划还本
                </span>
              ),
              dataSource: dictMapSelect['ASSETS_HBFS1'],
              initialValue: reportInfo?.jgbb_hbfs1,
              allowClear: true,
              disabled: disableStatus,
              span: 8,
            },
            {
              dataIndex: 'jgbb_jczclx',
              title: '基础资产类型',
              helper: (
                <span>
                  资产包所包含基础资产的种类，例如信贷资产、票据、信用证、应收账款、
                  <br />
                  各类资产管理产品和收(受)益权等
                </span>
              ),
              type: DATA_ENTRY.INPUT,
              showTextArea: true,
              lineOne: true,
              disabled: disableStatus,
              initialValue: reportInfo?.jgbb_jczclx,
              span: 24,
              rules: [
                {
                  max: 200,
                  message: '字符不超过200！',
                },
              ],
            },
            {
              dataIndex: 'jgbb_cesyfpbl',
              title: '超额收益分配比例',
              helper: (
                <span>
                  根据现金流分配机制，基础资产回收款完成各分级、
                  <br />
                  各分档本金和收益分配后的超额收益分配部分，在各分级、
                  <br />
                  各分档的分配比例
                </span>
              ),
              type: DATA_ENTRY.INPUTNUMBER,
              precision: 5,
              unit: '%',
              disabled: disableStatus,
              initialValue: reportInfo?.jgbb_cesyfpbl || (reportInfo && reportInfo.jgbb_cesyfpbl == 0) ? parseFloat((reportInfo.jgbb_cesyfpbl * 100000) / 1000).toFixed(5) : null,
              rules: [{ pattern: /(^(?:\d|\d{0,2})(?:\.\d{0,5})?$)/, message: '字符不能超过8位,且大于等于0！' }],
              span: '8',
            },
            {
              dataIndex: 'jgbb_rzrnbxypj',
              title: '融资人内部信用评级',
              helper: (
                <span>
                  理财产品发行机构内部对融资人如期足额偿还债务本息的
                  <br />
                  能力和意愿的评价
                </span>
              ),
              type: DATA_ENTRY.INPUT,
              disabled: disableStatus,
              initialValue: reportInfo?.jgbb_rzrnbxypj,
              span: 8,
              rules: [
                {
                  max: 10,
                  message: '字符不超过10！',
                },
                {
                  required: permissonBefore && true,
                  message: '请输入',
                },
              ],
            },
            {
              dataIndex: 'jgbb_wbpjjgmcjdrzrpjjg',
              title: '外部评级机构名称及对融资人评级结果',
              helper: '外部专业性的评级公司名称及对融资人主体的信用评级结果',
              type: DATA_ENTRY.INPUT,
              showTextArea: true,
              lineOne: true,
              disabled: disableStatus,
              initialValue: reportInfo?.jgbb_wbpjjgmcjdrzrpjjg,
              span: 24,
              rules: [
                {
                  max: 200,
                  message: '字符不超过200！',
                },
              ],
            },
            {
              dataIndex: 'jgbb_rzrlxgm',
              title: '融资人类型(按规模划分)',
              type: DATA_ENTRY.SELECT,
              helper: '指按规模划分的资产融资人类型',
              onChange: (e) => {
                this.props?.onBaseInfoChange({ jgbb_rzrlxgm: e }), this.changeStatus({ jgbb_rzrlxgm: e });
              },
              dataSource: dictMapSelect['ASSETS_RZRLXGM'],
              initialValue: reportInfo?.jgbb_rzrlxgm,
              allowClear: true,
              disabled: disableStatus,
              span: 8,
              rules: [
                {
                  required: permissonBefore && true,
                  message: '请选择！',
                },
              ],
            },
            {
              dataIndex: 'jgbb_rzrlxjs',
              title: '融资人类型(按技术领域划分)',
              type: DATA_ENTRY.SELECT,
              helper: '指按技术领域划分的资产融资人类型',
              onChange: (e) => {
                this.props?.onBaseInfoChange({ jgbb_rzrlxjs: e }), this.changeStatus({ jgbb_rzrlxjs: e });
              },
              dataSource: dictMapSelect['ASSETS_RZRLXJS'],
              initialValue: reportInfo?.jgbb_rzrlxjs,
              allowClear: true,
              disabled: disableStatus,
              span: 8,
              rules: [
                {
                  required: permissonBefore && true,
                  message: '请选择！',
                },
              ],
            },
            {
              dataIndex: 'jgbb_rzrlxjj',
              title: '融资人类型(按经济类型划分)',
              type: DATA_ENTRY.SELECT,
              helper: '指按经济类型划分的资产融资人类型',
              dataSource: dictMapSelect['ASSETS_RZRLXJJ'],
              onChange: (e) => {
                this.props?.onBaseInfoChange({ jgbb_rzrlxjj: e }), this.changeStatus({ jgbb_rzrlxjj: e });
              },
              initialValue: reportInfo?.jgbb_rzrlxjj,
              allowClear: true,
              disabled: disableStatus,
              span: 8,
              rules: [
                {
                  required: permissonBefore && true,
                  message: '请选择！',
                },
              ],
            },
            {
              dataIndex: 'jgbb_rzxm',
              title: '融资项目',
              helper: (
                <span>
                  资产所募集资金实际投资项目的名称，
                  <br />
                  需填写融资项目全称
                </span>
              ),
              type: DATA_ENTRY.INPUT,
              showTextArea: true,
              lineOne: true,
              disabled: disableStatus,
              initialValue: reportInfo?.jgbb_rzxm,
              span: 24,
              rules: [
                {
                  max: 200,
                  message: '字符不超过200！',
                },
              ],
            },
            {
              dataIndex: 'jgbb_rzrsshy',
              title: '融资人所属行业',
              helper: '融资人所属的行业类型',
              type: DATA_ENTRY.FUNDAPPLICATIONINDUSTRYC,
              disabled: disableStatus,
              initialValue: reportInfo?.jgbb_rzrsshy,
              span: 8,
              allowClear: true,
              rules: [
                {
                  required: permissonBefore && true,
                  message: '请选择！',
                },
              ],

              // dataIndex:'jgbb_rzrsshy',
              // title: '融资人所属行业',
              // helper:'融资人所属的行业类型',
              // type:DATA_ENTRY.INDUSTRYC,
              // disabled:disableStatus,
              // initialValue:reportInfo?.jgbb_rzrsshy,
              // multiple:false,
              // span:8,
              // rules:[{
              //     required:permissonBefore && true ,message:'请选择！'
              // }]
            },
            {
              dataIndex: 'jgbb_rzxmsshy',
              title: '融资项目所属行业',
              helper: '融资项目所属的行业类型',
              type: DATA_ENTRY.FUNDAPPLICATIONINDUSTRYC,
              disabled: disableStatus,
              initialValue: reportInfo?.jgbb_rzxmsshy,
              span: 8,
              allowClear: true,
              rules: [
                {
                  required: permissonBefore && true,
                  message: '请选择！',
                },
              ],

              // dataIndex:'jgbb_rzxmsshy',
              // title: '融资项目所属行业',
              // helper:'融资项目所属的行业类型',
              // type:DATA_ENTRY.INDUSTRYC,
              // disabled:disableStatus,
              // multiple:false,
              // initialValue:reportInfo?.jgbb_rzxmsshy,
              // span:8,
              // rules:[{
              //     required:permissonBefore && true ,message:'请选择！'
              // }]
            },
            {
              dataIndex: 'jgbb_xmsfsyzdjkhyhly',
              title: '项目是否属于重点监控行业和领域',
              type: DATA_ENTRY.SELECT,
              helper: '项目是否属于国家重点监控行业和领域',
              isTrueFalseJudge: true,
              initialValue: reportInfo?.jgbb_xmsfsyzdjkhyhly,
              allowClear: true,
              onChange: (e) => {
                this.props?.onBaseInfoChange({ jgbb_xmsfsyzdjkhyhly: e }), this.changeStatus({ jgbb_xmsfsyzdjkhyhly: e });
              },
              disabled: disableStatus,
              span: 8,
              rules: [
                {
                  required: permissonBefore && true,
                  message: '请选择！',
                },
              ],
            },
            {
              dataIndex: 'jgbb_zdjkhyhlylb',
              title: '重点监控行业和领域类别',
              type: DATA_ENTRY.SELECT,
              helper: (
                <span>
                  1.房地产：包括房地产开发经营、物业管理、房地产中介服务、自有房地产经营活动和其他房地产业。
                  <br />
                  房地产开发经营，指房地产开发企业进行的房屋、基础设施建设等开发，以及转让房地产开发项目或者销售、
                  <br />
                  出租房屋等活动。物业管理，指物业服务企业按照合同约定，对房屋及配套的设施设备和相关场地进行维修、
                  <br />
                  养护、管理，维护环境卫生和相关秩序的活动。房地产中介服务，
                  <br />
                  指房地产咨询、房地产价格评估、房地产经纪等活动。自有房地产经营活动，指除房地产开发商、房地产中介、
                  <br />
                  物业公司以外的单位和居民住户对自有房地产（土地、住房、生产经营用房和办公用房）的买卖和以营利为目的的租赁活动，
                  <br />
                  以及房地产管理部门和企事业、机关提供的非营利租赁服务，还包括居民居住自有住房所形成的住房服务；
                  <br />
                  2.地方政府融资平台：由地方政府出资由地方政府出资设立并承担连带还款责任的机关、事业、企业三类法人。
                  <br />
                  登记口径与《中国银监会办公厅关于地方政府融资平台融资全口径统计的通知》（银监办发 2013〔175〕号）文中，
                  <br />
                  银行理财资金投资平台情况（其中：非标准化债权资产类）相同；
                  <br />
                  3.“铁公基”：铁路、高速公路、基础设施领域；
                  <br />
                  4.“两高一剩”行业：高污染、高能耗的资源性的行业。“一剩行业”是指产能过剩行业；
                  <br />
                  5.如选择“其他”选项，需在重点监控行业和领域类别说明中注明行业具体类型
                </span>
              ),
              dataSource: dictMapSelect['ASSETS_ZDJKHYHLYLB'],
              initialValue: reportInfo?.jgbb_zdjkhyhlylb,
              allowClear: true,
              onChange: (e) => {
                this.props?.onBaseInfoChange({ jgbb_zdjkhyhlylb: e }), this.changeStatus({ jgbb_zdjkhyhlylb: e });
              },
              disabled: disableStatus || jgbb_xmsfsyzdjkhyhly == '0',
              span: 8,
              rules: [
                {
                  required: jgbb_xmsfsyzdjkhyhly == '1',
                  message: '请选择！',
                },
              ],
            },
            {
              dataIndex: 'jgbb_zdjkhyhlylbsm',
              title: '重点监控行业和领域类别说明',
              helper: '对于重点监控行业和领域类别的详细说明',
              type: DATA_ENTRY.INPUT,
              showTextArea: true,
              lineOne: true,
              disabled: disableStatus || jgbb_xmsfsyzdjkhyhly == '0',
              initialValue: reportInfo?.jgbb_zdjkhyhlylbsm,
              span: 24,
              rules: [
                {
                  max: 256,
                  message: '字符不超过256！',
                },
                {
                  required: jgbb_zdjkhyhlylb == '99',
                  message: '请填写！',
                },
              ],
            },
            {
              dataIndex: 'jgbb_dbqksm',
              title: '担保情况说明',
              type: DATA_ENTRY.INPUT,
              showTextArea: true,
              lineOne: true,
              disabled: disableStatus || !guaranteeWay,
              initialValue: reportInfo?.jgbb_dbqksm,
              span: 24,
              rules: [
                {
                  max: 200,
                  message: '字符不超过200！',
                },
                {
                  required: !!guaranteeWay,
                  message: '请填写',
                },
              ],
            },
            {
              dataIndex: 'jgbb_dzywlx',
              title: '抵质押物类型',
              type: DATA_ENTRY.SELECT,
              dataSource: dictMapSelect['ASSETS_DZYWLX'],
              initialValue: reportInfo?.jgbb_dzywlx,
              allowClear: true,
              disabled: disableStatus || (guaranteeWay != '03' && guaranteeWay != '04'),
              onChange: (e) => {
                this.props?.onBaseInfoChange({ jgbb_dzywlx: e }), this.changeStatus({ jgbb_dzywlx: e });
              },
              span: 8,
              rules: [
                {
                  required: guaranteeWay == '03' || guaranteeWay == '04',
                  message: '请选择！',
                },
              ],
            },
            {
              dataIndex: 'jgbb_dzywjz',
              title: '抵质押物价值',
              helper: (
                <span>
                  抵质押物的价值。该要素以人民币为填报单位，对于其他币种，
                  <br />
                  需要以抵质押相关合同条款订立当日外管局公布的汇率折算成人民币报送
                </span>
              ),
              type: DATA_ENTRY.INPUTNUMBER,
              precision: 2,
              unit: '元',
              disabled: disableStatus || (guaranteeWay != '03' && guaranteeWay != '04'),
              initialValue: reportInfo?.jgbb_dzywjz,
              rules: [
                { pattern: /(^(?:\d|\d{0,12})(?:\.\d{0,2})?$)/, message: '字符不能超过15位,且大于等于0！' },
                { required: guaranteeWay == '03' || guaranteeWay == '04', message: '请输入' },
              ],
              span: '8',
            },
            {
              dataIndex: 'jgbb_dbxz1',
              title: '担保性质',
              type: DATA_ENTRY.SELECT,
              helper: '担保人承担的法律责任性质',
              dataSource: dictMapSelect['ASSETS_DBXZ1'],
              initialValue: reportInfo?.jgbb_dbxz1,
              allowClear: true,
              disabled: disableStatus || (guaranteeWay != '01' && guaranteeWay != '02'),
              span: 8,
              rules: [
                {
                  required: guaranteeWay == '01' || guaranteeWay == '02',
                  message: '请选择！',
                },
              ],
            },
            {
              dataIndex: 'jgbb_dbryrzrgx',
              title: '担保人与融资人关系',
              type: DATA_ENTRY.SELECT,
              helper: '担保人承担的法律责任性质',
              dataSource: dictMapSelect['ASSETS_DBRYRZRGX'],
              initialValue: reportInfo?.jgbb_dbryrzrgx,
              allowClear: true,
              disabled: disableStatus || (guaranteeWay != '01' && guaranteeWay != '02'),
              onChange: (e) => {
                this.props?.onBaseInfoChange({ jgbb_dbryrzrgx: e }), this.changeStatus({ jgbb_dbryrzrgx: e });
              },
              span: 8,
              rules: [
                {
                  required: guaranteeWay == '01' || guaranteeWay == '02',
                  message: '请选择！',
                },
              ],
            },
            {
              dataIndex: 'jgbb_zcnbpj1',
              title: '资产内部评级',
              type: DATA_ENTRY.INPUT,
              helper: '发行机构内部对资产项目本身的风险评级结果',
              disabled: disableStatus,
              initialValue: reportInfo?.jgbb_zcnbpj1,
              span: 8,
              rules: [
                {
                  max: 20,
                  message: '字符不超过20！',
                },
                {
                  required: permissonBefore && true,
                  message: '请输入',
                },
              ],
            },
            {
              dataIndex: 'jgbb_hqlx1',
              title: '含权类型',
              type: DATA_ENTRY.SELECT,
              helper: (
                <span>
                  选择权条款的种类，根据选择权条款中约定的权力行使方、
                  <br />
                  权力种类划分为发行人赎回选择权、投资人回售选择权等类型
                </span>
              ),
              dataSource: dictMapSelect['ASSETS_HQLX1'],
              initialValue: reportInfo?.jgbb_hqlx1,
              allowClear: true,
              disabled: disableStatus,
              onChange: (e) => {
                this.props?.onBaseInfoChange({ jgbb_hqlx1: e }), this.changeStatus({ jgbb_hqlx1: e });
              },
              span: 8,
            },
            {
              dataIndex: 'jgbb_xqfs1',
              title: '行权方式',
              type: DATA_ENTRY.SELECT,
              helper: '选择权的履约方式',
              dataSource: dictMapSelect['ASSETS_XQFS1'],
              initialValue: reportInfo?.jgbb_xqfs1,
              allowClear: true,
              disabled: disableStatus || !jgbb_hqlx1,
              onChange: (e) => {
                this.props?.onBaseInfoChange({ jgbb_xqfs1: e }), this.changeStatus({ jgbb_xqfs1: e });
              },
              span: 8,
              rules: [
                {
                  required: (assetType == '3' || assetType == '2' || assetType == '4' || assetType == '6' || assetType == '7' || assetType == '8') && !!jgbb_hqlx1,
                  message: '请选择！',
                },
              ],
            },
            {
              dataIndex: 'jgbb_gdxqr1',
              title: '固定行权日',
              helper: (
                <span>
                  对选择权类型为欧式期权的选择权，
                  <br />
                  约定的选择权行使日期(理论行权日)
                </span>
              ),
              type: DATA_ENTRY.SINGLEDATE,
              disabled:
                disableStatus ||
                !((assetType == '3' || assetType == '2' || assetType == '4' || assetType == '6' || assetType == '7' || assetType == '8') && !!jgbb_hqlx1 && jgbb_xqfs1 == '02'),
              span: 8,
              initialValue: reportInfo?.jgbb_gdxqr1 ? moment(new Date(reportInfo?.jgbb_gdxqr1)) : undefined,
              rules: [
                {
                  required:
                    (assetType == '3' || assetType == '2' || assetType == '4' || assetType == '6' || assetType == '7' || assetType == '8') && !!jgbb_hqlx1 && jgbb_xqfs1 == '02',
                  message: '请选择！',
                },
              ],
            },
            {
              dataIndex: 'jgbb_scxqr1',
              title: '首次行权日期',
              helper: '以一定间隔无限次行使的选择权的首次行权日期',
              type: DATA_ENTRY.SINGLEDATE,
              disabled:
                disableStatus ||
                !((assetType == '3' || assetType == '2' || assetType == '4' || assetType == '6' || assetType == '7' || assetType == '8') && !!jgbb_hqlx1 && jgbb_xqfs1 == '03'),
              span: 8,
              initialValue: reportInfo?.jgbb_scxqr1 ? moment(new Date(reportInfo?.jgbb_scxqr1)) : undefined,
              rules: [
                {
                  required:
                    (assetType == '3' || assetType == '2' || assetType == '4' || assetType == '6' || assetType == '7' || assetType == '8') && !!jgbb_hqlx1 && jgbb_xqfs1 == '03',
                  message: '请选择！',
                },
              ],
            },
            {
              dataIndex: 'jgbb_xqzq1',
              title: '行权周期',
              helper: (
                <span>
                  约定的选择权在约定的区间中，
                  <br />
                  可以行使权利的本次日期与下次日期之间的间隔
                </span>
              ),
              type: DATA_ENTRY.INPUTNUMBER,
              precision: 0,
              unit: '日',
              disabled:
                disableStatus ||
                !((assetType == '3' || assetType == '2' || assetType == '4' || assetType == '6' || assetType == '7' || assetType == '8') && !!jgbb_hqlx1 && jgbb_xqfs1 == '03'),
              initialValue: reportInfo?.jgbb_xqzq1,
              rules: [
                { pattern: /^[0-9]\d{0,4}$/, message: '字符不能超过5位,且大于等于0！' },
                {
                  required:
                    (assetType == '3' || assetType == '2' || assetType == '4' || assetType == '6' || assetType == '7' || assetType == '8') && !!jgbb_hqlx1 && jgbb_xqfs1 == '03',
                  message: '请输入',
                },
              ],
              span: '8',
            },
            {
              dataIndex: 'jgbb_xqjg1',
              title: '行权价格',
              helper: (
                <span>
                  含权资产行使权利时的净价，并扣除当日因分期还本兑付的本金值，
                  <br />
                  不包含应计利息
                </span>
              ),
              type: DATA_ENTRY.INPUTNUMBER,
              precision: 4,
              unit: 'CNY',
              disabled:
                disableStatus ||
                !(
                  (assetType == '3' || assetType == '2' || assetType == '4' || assetType == '6' || assetType == '7' || assetType == '8') &&
                  (jgbb_hqlx1 == '01' || jgbb_hqlx1 == '04')
                ),
              initialValue: reportInfo?.jgbb_xqjg1,
              rules: [
                { pattern: /^[0-9]\d{0,16}$/, message: '字符不能超过17位！' },
                {
                  required:
                    (assetType == '3' || assetType == '2' || assetType == '4' || assetType == '6' || assetType == '7' || assetType == '8') &&
                    (jgbb_hqlx1 == '01' || jgbb_hqlx1 == '04'),
                  message: '请输入',
                },
              ],
              span: '8',
            },
            {
              dataIndex: 'jgbb_yxtklx',
              title: '永续条款类型',
              type: DATA_ENTRY.SELECT,
              helper: '资产是否约定了可续期或永续条款',
              dataSource: dictMapSelect['ASSETS_YXTKLX'],
              initialValue: reportInfo?.jgbb_yxtklx,
              allowClear: true,
              disabled: disableStatus,
              onChange: (e) => {
                this.props?.onBaseInfoChange({ jgbb_yxtklx: e }), this.changeStatus({ jgbb_yxtklx: e });
              },
              span: 8,
              rules: [
                {
                  required: assetType == '3' || assetType == '2' || assetType == '4' || assetType == '6' || assetType == '7' || assetType == '8',
                  message: '请选择！',
                },
              ],
            },
            {
              dataIndex: 'jgbb_lxdytklx',
              title: '利息递延条款类型',
              type: DATA_ENTRY.SELECT,
              helper: (
                <span>
                  资产是否约定了利息递延条款，
                  <br />
                  允许发行人在一定条件下延迟支付利息
                </span>
              ),
              dataSource: dictMapSelect['ASSETS_LXDYTKLX'],
              initialValue: reportInfo?.jgbb_lxdytklx,
              allowClear: true,
              disabled: disableStatus,
              onChange: (e) => {
                this.props?.onBaseInfoChange({ jgbb_lxdytklx: e }), this.changeStatus({ jgbb_lxdytklx: e });
              },
              span: 8,
              rules: [
                {
                  required: assetType == '3' || assetType == '2' || assetType == '4' || assetType == '6' || assetType == '7' || assetType == '8',
                  message: '请选择！',
                },
              ],
            },
            {
              dataIndex: 'jgbb_dylxsfjx',
              title: '递延利息是否计息',
              type: DATA_ENTRY.SELECT,
              isTrueFalseJudge: true,
              initialValue: reportInfo?.jgbb_dylxsfjx,
              allowClear: true,
              disabled: jgbb_lxdytklx == '01',
              span: 8,
              rules: [
                {
                  required:
                    (assetType == '3' || assetType == '2' || assetType == '4' || assetType == '6' || assetType == '7' || assetType == '8') &&
                    (jgbb_lxdytklx == '02' || jgbb_lxdytklx == '03'),
                  message: '请选择！',
                },
              ],
            },
            {
              dataIndex: 'jgbb_sccdjrq',
              title: '首次重定价日期',
              helper: '永续资产存续期内首次重定利率的日期',
              type: DATA_ENTRY.SINGLEDATE,
              disabled:
                disableStatus ||
                !(
                  (assetType == '3' || assetType == '2' || assetType == '4' || assetType == '6' || assetType == '7' || assetType == '8') &&
                  (jgbb_yxtklx == '01' || jgbb_yxtklx == '02')
                ),
              span: 8,
              initialValue: reportInfo?.jgbb_sccdjrq ? moment(new Date(reportInfo?.jgbb_sccdjrq)) : undefined,
              rules: [
                {
                  required:
                    (assetType == '3' || assetType == '2' || assetType == '4' || assetType == '6' || assetType == '7' || assetType == '8') &&
                    (jgbb_yxtklx == '01' || jgbb_yxtklx == '02'),
                  message: '请选择！',
                },
              ],
            },
            {
              dataIndex: 'jgbb_cdjzq1',
              title: '重定价周期',
              helper: (
                <span>
                  永续资产在首次重定价日期后，
                  <br />
                  各个重定价日期之间的日期长度
                </span>
              ),
              type: DATA_ENTRY.INPUTNUMBER,
              precision: 0,
              disabled:
                disableStatus ||
                !(
                  (assetType == '3' || assetType == '2' || assetType == '4' || assetType == '6' || assetType == '7' || assetType == '8') &&
                  (jgbb_yxtklx == '01' || jgbb_yxtklx == '02')
                ),
              initialValue: reportInfo?.jgbb_cdjzq1,
              rules: [
                { pattern: /^[1-9]\d{0,4}$/, message: '字符不能超过5位,且大于0！' },
                {
                  required:
                    (assetType == '3' || assetType == '2' || assetType == '4' || assetType == '6' || assetType == '7' || assetType == '8') &&
                    (jgbb_yxtklx == '01' || jgbb_yxtklx == '02'),
                  message: '请输入',
                },
              ],
              span: '8',
            },
            {
              dataIndex: 'jgbb_bfshbs1',
              title: '部分赎回标识',
              type: DATA_ENTRY.SELECT,
              helper: '发行条款是否允许发行人部分赎回',
              isTrueFalseJudge: true,
              initialValue: reportInfo?.jgbb_bfshbs1,
              allowClear: true,
              disabled: disableStatus,
              span: 8,
              rules: [
                {
                  required: assetType == '3' || assetType == '2' || assetType == '4' || assetType == '6' || assetType == '7' || assetType == '8',
                  message: '请选择！',
                },
              ],
            },
            {
              dataIndex: 'jgbb_bfshbl',
              title: '部分赎回比例',
              helper: (
                <span>
                  发行文件中约定的部分赎回比例，
                  <br />
                  或公告的实际部分赎回比例
                </span>
              ),
              type: DATA_ENTRY.INPUTNUMBER,
              precision: 5,
              unit: '%',
              disabled: disableStatus,
              initialValue: reportInfo?.jgbb_bfshbl || (reportInfo && reportInfo.jgbb_bfshbl == 0) ? parseFloat((reportInfo?.jgbb_bfshbl * 100000) / 1000).toFixed(5) : null,
              rules: [{ pattern: /(^(?:\d|\d{0,2})(?:\.\d{0,5})?$)/, message: '字符不能超过8位,且大于等于0！' }],
              span: '8',
            },
            {
              dataIndex: 'jgbb_xzq1',
              title: '选择权',
              type: DATA_ENTRY.INPUT,
              helper: (
                <span>
                  非标资产对于提前赎回、买入返售、远期买回等相关权利的规定说明。
                  <br />
                  如无则填写“无”
                </span>
              ),
              disabled: disableStatus,
              initialValue: reportInfo?.jgbb_xzq1,
              span: 8,
              rules: [
                {
                  max: 60,
                  message: '字符不超过60！',
                },
                {
                  required: permissonBefore && true,
                  message: '请输入',
                },
              ],
            },
            {
              dataIndex: 'jgbb_xqtjsm1',
              title: '行权条件说明',
              type: DATA_ENTRY.INPUT,
              showTextArea: true,
              helper: (
                <span>
                  对于触发或行使上述选择权的条件说明。
                  <br />
                  如无则填写“无”
                </span>
              ),
              disabled: disableStatus,
              initialValue: reportInfo?.jgbb_xqtjsm1,
              span: 24,
              lineOne: true,
              rules: [
                {
                  max: 200,
                  message: '字符不超过200！',
                },
                {
                  required: permissonBefore && true,
                  message: '请输入',
                },
              ],
            },
            {
              // dataIndex:'jgbb_rzrssdq',
              // type: DATA_ENTRY.INPUT,
              type: DATA_ENTRY.ADDRESSC,
              helper: (
                <span>
                  详见《中华人民共和国行政区划代码》，
                  <br />
                  需填写至二级分类
                </span>
              ),
              provinceDataIndex: 'jgbb_rzrssdqsf',
              cityDataIndex: 'jgbb_rzrssdqcs',
              provInit: reportInfo?.jgbb_rzrssdqsf,
              provinceDataTitle: '融资人所属省',
              cityDataTitle: '融资人所属市',
              allowClear: true,
              cityInit: reportInfo?.jgbb_rzrssdqcs,
              disabled: disableStatus,
              // initialValue:reportInfo?.jgbb_rzrssdq,
              span: 8,
              rules: [
                [
                  {
                    required: permissonBefore && true,
                    message: '请选择省份',
                  },
                ],
                [
                  {
                    required: permissonBefore && true,
                    message: '请选择城市',
                  },
                ],
              ],
            },
            {
              dataIndex: 'jgbb_zxjgdm1',
              title: '增信机构代码',
              type: DATA_ENTRY.INPUT,
              helper: (
                <span>
                  担保増信机构的统一社会信用代码或组织机构代码。
                  <br />
                  应为 9 位或 18 位大写字母或数字，如果没有则填写“无”。
                  <br />
                  原则上，中国境内机构的“增信机构代码”应优先填写统一社会信用代码
                </span>
              ),
              disabled: disableStatus,
              initialValue: reportInfo?.jgbb_zxjgdm1,
              span: 8,
              rules: [
                {
                  // pattern:/^([0-9A-Z]{9}$)|([0-9A-Z]{18}$)/,message:'请填写为9位或18位大写字母或数字'
                  validator: this.handleMedianValidator,
                },
                {
                  required: assetType == '3' || assetType == '2' || assetType == '4' || assetType == '6' || assetType == '7' || assetType == '8',
                  message: '请输入',
                },
              ],
            },
            {
              dataIndex: 'jgbb_zxjgmc1',
              title: '增信机构名称',
              type: DATA_ENTRY.INPUT,
              showTextArea: true,
              lineOne: true,
              helper: <span>如果没有则填写“无”</span>,
              disabled: disableStatus,
              initialValue: reportInfo?.jgbb_zxjgmc1,
              span: 24,
              rules: [
                {
                  max: 200,
                  message: '字符位不超过200！',
                },
                {
                  required: assetType == '3' || assetType == '2' || assetType == '4' || assetType == '6' || assetType == '7' || assetType == '8',
                  message: '请输入',
                },
              ],
            },
            {
              dataIndex: 'jgbb_rzzfl',
              title: '融资总费率',
              helper: (
                <span>
                  非标资产项目合同中所涉及的各项费用的合计费率。
                  <br />
                  如无则填写“0”。若此要素不为 0，则托管费、
                  <br />
                  委贷费等费用的具体情况、费用计算公式需在备注中说明
                </span>
              ),
              onChange: (e) => {
                this.props?.onBaseInfoChange({ jgbb_rzzfl: e }), this.changeStatus({ jgbb_rzzfl: e });
              },
              type: DATA_ENTRY.INPUTNUMBER,
              precision: 5,
              unit: '%',
              disabled: disableStatus,
              initialValue: reportInfo?.jgbb_rzzfl || (reportInfo && reportInfo.jgbb_rzzfl == 0) ? reportInfo?.jgbb_rzzfl * 100 : null,
              rules: [
                { pattern: /(^(?:\d|\d{0,2})(?:\.\d{0,5})?$)/, message: '字符不能超过8位,且大于等于0！' },
                { required: permissonBefore && true, message: '请输入' },
              ],
              span: '8',
            },
            {
              dataIndex: 'jgbb_rzrzzjgshxydm',
              title: '融资人组织机构（社会信用）代码',
              type: DATA_ENTRY.INPUT,
              helper: (
                <span>
                  融资人组织机构代码证上的组织机构代码，或法人和其他组织的统一社会信用代码。
                  <br />
                  1.应为 9 或 18 位大写字母或数字。如19389089-X 则填写为 19389089X，
                  <br />
                  中间“-”不输入；
                  <br />
                  2.原则上，中国境内机构的“融资人组织机构（社会信用）代码”应优先填写统一社会信用代码，
                  <br />
                  如无则填写 000000000
                </span>
              ),
              disabled: disableStatus,
              initialValue: reportInfo?.jgbb_rzrzzjgshxydm,
              span: 8,
              rules: [
                {
                  pattern: /^([0-9A-Z]{9}$)|([0-9A-Z]{18}$)/,
                  message: '请填写为9位或18位大写字母或数字',
                },
                {
                  required: permissonBefore && true,
                  message: '请输入',
                },
              ],
            },
            {
              dataIndex: 'jgbb_bz1',
              title: '备注',
              type: DATA_ENTRY.INPUT,
              showTextArea: true,
              disabled: disableStatus,
              initialValue: reportInfo?.jgbb_bz1,
              lineOne: true,
              span: 24,
              rules: [
                {
                  max: 256,
                  message: '字符位不超过256！',
                },
                {
                  required:
                    jgbb_ssyqlx1 == '99' ||
                    jgbb_jzllzl == '99' ||
                    jgbb_rzrlxgm == '99' ||
                    jgbb_rzrlxjs == '99' ||
                    jgbb_rzrlxjj == '99' ||
                    jgbb_dzywlx == '99' ||
                    jgbb_dbryrzrgx == '99' ||
                    jgbb_rzzfl > 0,
                  message: '请输入',
                },
              ],
            },
            {
              dataIndex: 'jgbb_txbffl',
              title: '投向部分分类',
              type: DATA_ENTRY.SELECT,
              dataSource: dictMapSelect['ASSETS_TXBFFL'],
              initialValue: reportInfo?.jgbb_txbffl,
              disabled: disableStatus,
              hide: assetType != '2',
              rules: [
                {
                  required: true,
                  message: '请输入',
                },
              ],
            },
          ]}
          autoLayout={true}
          onRef={(ref) => {
            this.state.zcReportInfoRef = ref;
          }}
        ></FormGroup>
      </>
    );
  }
}
export default connect(({ nonstandarmaintenanceNewM }) => ({ nonstandarmaintenanceNewM }))(ZcReportInfo);
